const express = require('express');
const router = express.Router();
const axios = require('axios');
const multer = require('multer'); // 需要安装: npm install multer
const FormData = require('form-data'); // 需要安装: npm install form-data
const dotenv = require('dotenv');

// 加载环境变量
dotenv.config();

// 从环境变量获取后端服务地址，默认为 https://localhost:8080
const BACKEND_API_URL = process.env.BACKEND_API_URL || 'https://localhost:8080';

// 配置文件上传
const storage = multer.memoryStorage();
const upload = multer({ 
    storage: storage,
    limits: { fileSize: 10 * 1024 * 1024 } // 限制文件大小为10MB
});

// 处理流式聊天请求
router.post('/chat/assistant', upload.single('file'), async (req, res) => {
    const { userInput, fileIds } = req.body;
    
    if (!userInput) {
        return res.status(400).json({ error: '消息不能为空' });
    }
    
    try {
        // 设置响应头以支持流式传输
        res.setHeader('Content-Type', 'text/event-stream');
        res.setHeader('Cache-Control', 'no-cache');
        res.setHeader('Connection', 'keep-alive');
        
        // 准备表单数据
        const formData = new FormData();
        formData.append('userInput', userInput);
        
        // 如果有文件ID列表，添加到表单
        if (fileIds) {
            formData.append('fileIds', fileIds); // 直接传递原始的 JSON 字符串
            console.log("转发 fileIds:", fileIds); // 添加调试日志
        }
        
        // 如果有文件，添加到表单
        if (req.file) {
            const fileBuffer = req.file.buffer;
            formData.append('file', fileBuffer, {
                filename: req.file.originalname,
                contentType: req.file.mimetype
            });
        }
        
        // 代理到 Spring Boot 后端，使用配置的URL
        const response = await axios.post(
            `${BACKEND_API_URL}/api/chat/assistant`,
            formData,
            {
                responseType: 'stream',
                headers: formData.getHeaders(),
                maxContentLength: Infinity,
                maxBodyLength: Infinity
            }
        );

        // 直接转发 Spring Boot 的响应流
        response.data.pipe(res);
        
        // 处理连接关闭
        req.on('close', () => {
            if (response.data) {
                response.data.destroy();
            }
        });
    } catch (error) {
        console.error('处理聊天请求时出错:', error);
        res.write(`data: ${JSON.stringify({ error: true, content: "连接后端服务失败: " + error.message })}\n\n`);
        res.end();
    }
});

// 文件上传接口
router.post('/upload-file', upload.single('file'), async (req, res) => {
    try {
        if (!req.file) {
            return res.status(400).json({ error: '未提供文件' });
        }
        
        // 创建表单数据
        const formData = new FormData();
        formData.append('file', req.file.buffer, {
            filename: req.file.originalname,
            contentType: req.file.mimetype
        });
        
        // 将请求转发到 Spring Boot 后端，使用配置的URL
        const response = await axios.post(
            `${BACKEND_API_URL}/api/upload-file`,
            formData,
            {
                headers: formData.getHeaders()
            }
        );
        
        // 返回后端处理结果
        res.json(response.data);
    } catch (error) {
        console.error('文件上传失败:', error);
        res.status(500).json({ 
            error: '文件上传处理失败',
            message: error.message
        });
    }
});

// 文本转语音接口
router.post('/text-to-speech', async (req, res) => {
    try {
        const { text } = req.body;
        
        if (!text) {
            return res.status(400).json({ error: '文本不能为空' });
        }
        
        // 转发请求到后端
        const response = await axios.post(
            `${BACKEND_API_URL}/api/text-to-speech`,
            { text },
            { responseType: 'arraybuffer' }
        );
        
        // 设置正确的内容类型
        res.set('Content-Type', 'audio/wav');
        res.send(response.data);
    } catch (error) {
        console.error('文本转语音出错:', error);
        res.status(500).json({ 
            error: '文本转语音失败',
            message: error.message
        });
    }
});

// 保留原有的代理端点以兼容旧代码
router.get('/proxy-assistant', async (req, res) => {
    const { userInput } = req.query;
    
    if (!userInput) {
        return res.status(400).json({ error: '消息不能为空' });
    }
    
    try {
        // 设置响应头
        res.setHeader('Content-Type', 'text/event-stream');
        res.setHeader('Cache-Control', 'no-cache');
        res.setHeader('Connection', 'keep-alive');
        
        // 通过新的 POST 端点重定向
        const formData = new FormData();
        formData.append('userInput', userInput);
        
        const response = await axios.post(
            `${BACKEND_API_URL}/api/chat/assistant`,
            formData,
            {
                responseType: 'stream',
                headers: formData.getHeaders()
            }
        );
        
        // 转发响应
        response.data.pipe(res);
    } catch (error) {
        console.error('代理请求出错:', error);
        res.write(`data: ${JSON.stringify({ content: "连接后端服务失败", error: true })}\n\n`);
        res.end();
    }
});

// 获取支持的模型列表
router.get('/models', (req, res) => {
    const models = [
        { id: 'gpt-3.5-turbo', name: 'GPT-3.5 Turbo', provider: 'OpenAI' },
        { id: 'deepseek-chat', name: 'DeepSeek Chat', provider: 'DeepSeek' }
    ];
    res.json(models);
});

// 数字人会话创建接口
router.post('/avatar/session', async (req, res) => {
    try {
        console.log('[数字人] 开始创建会话...');
        
        // 转发请求到后端
        const response = await axios.post(
            `${BACKEND_API_URL}/api/avatar/session`
        );
        
        console.log('[数字人] 会话创建成功:', response.data);
        res.json(response.data);
    } catch (error) {
        console.error('[数字人] 创建会话失败:', error);
        res.status(500).json({ 
            error: '创建数字人会话失败',
            message: error.message
        });
    }
});

// 数字人会话状态查询接口
router.get('/avatar/session/:sessionId', async (req, res) => {
    try {
        const sessionId = req.params.sessionId;
        console.log(`[数字人] 查询会话状态: ${sessionId}`);
        
        // 转发请求到后端
        const response = await axios.get(
            `${BACKEND_API_URL}/api/avatar/session/${sessionId}`
        );
        
        console.log('[数字人] 会话状态:', response.data);
        res.json(response.data);
    } catch (error) {
        console.error('[数字人] 查询会话状态失败:', error.message);
        res.status(500).json({ 
            error: '查询数字人会话状态失败',
            message: error.message
        });
    }
});

// 数字人发送文本接口
router.post('/avatar/session/:sessionId/text', async (req, res) => {
    try {
        const sessionId = req.params.sessionId;
        const { text, interrupt } = req.body;
        
        // 转发请求到后端
        const response = await axios.post(
            `${BACKEND_API_URL}/api/avatar/session/${sessionId}/text`,
            null,
            {
                params: {
                    text,
                    interrupt
                }
            }
        );
        
        res.json(response.data);
    } catch (error) {
        console.error('向数字人发送文本失败:', error);
        res.status(500).json({ 
            error: '向数字人发送文本失败',
            message: error.message
        });
    }
});

// 数字人打断接口
router.post('/avatar/session/:sessionId/interrupt', async (req, res) => {
    try {
        const sessionId = req.params.sessionId;
        
        // 转发请求到后端
        const response = await axios.post(
            `${BACKEND_API_URL}/api/avatar/session/${sessionId}/interrupt`
        );
        
        res.json(response.data);
    } catch (error) {
        console.error('打断数字人播报失败:', error);
        res.status(500).json({ 
            error: '打断数字人播报失败',
            message: error.message
        });
    }
});

// 数字人会话关闭接口
router.post('/avatar/session/:sessionId/close', async (req, res) => {
    try {
        const { sessionId } = req.params;
        console.log('--------------------------------');
        console.log('[数字人] API路由: 接收到关闭会话请求');
        console.log(`[数字人] API路由: 会话ID = ${sessionId}`);
        debugger;
        
        // 转发请求到后端
        console.log(`[数字人] API路由: 转发请求到 ${BACKEND_API_URL}/api/avatar/session/${sessionId}/close`);
        const response = await axios.post(
            `${BACKEND_API_URL}/api/avatar/session/${sessionId}/close`
        );
        
        console.log('[数字人] API路由: 会话关闭成功');
        console.log('--------------------------------');
        res.json(response.data);
    } catch (error) {
        console.error('[数字人] API路由: 关闭会话失败:', error);
        console.log('--------------------------------');
        res.status(500).json({ 
            error: '关闭数字人会话失败',
            message: error.message
        });
    }
});

module.exports = router;